def solution(open = open):
    che = [False, False, True, True] + [False, True] * 4998  # 에라토스테네스의 체
    # 0과 1은 소수가 아니므로 False, 2와 3부터 소수이므로 True,
    # 이후 짝수만 False, 홀수만 True로 초기화한다.
    for i, is_prime in enumerate(che[3:int(10000 ** .5) + 1:2], start=1):
        # 3부터 10000(문제에서의 최댓값)의 제곱근까지 홀수만 검사한다.
        if not is_prime:
            # 홀수가 아니면 넘긴다.
            continue
        prime = i * 2 + 1
        # 인덱스 값에서 원래 수를 구한다.
        che[prime * prime::2 * prime] = [False] * ((10000 - prime * prime) // (2 * prime) + 1)
        # prime의 제곱부터 2 * prime 간격으로 False로 초기화한다.
        # 제곱부터인 이유는 그보다 작은 prime의 배수는 이미 prime보다
        # 작은 수와의 공배수이므로 False로 초기화되어 있기 때문이다.
        # 2 * prime 간격으로 초기화하는 이유는 짝수는 이미 False로 초기화되어 있기 때문이다.
    input = iter(open(0).read().split("\n")).__next__
    # open(0)은 표준 입력을 의미한다. 알면 왜 쓰는지 알테고 모르면 그냥 그렇구나 하면 된다.
    # open(0).read().split("\n")은 표준 입력을 한 줄씩 읽어서 리스트로 만든다.
    # 이를 iter로 반복자로 만들고, __next__로 다음 값을 가져오는 식으로 input 함수를 재정의한다.
    # 그럼 더 빠른 input 함수를 쓸 수 있다!
    for _ in range(int(input())):
        # 테스트 케이스의 개수만큼 반복한다.
        n = int(input())
        # n을 입력받는다.
        if n == 4:
            # n이 4이면 2 2를 출력한다.
            print(2, 2)
            # 4만 따로 처리하는 이유는 이후 n을 반으로 나누어 짝수면 1을 빼서 홀수로 바꿀건데,
            # 이렇게 되면 4는 처리하지 못하기 때문이다.
        n2 = n // 2
        if n2 % 2 == 0:
            n2 -= 1
        # n을 반으로 나누어 짝수면 1을 빼서 홀수로 바꾼다.
        for prime in range(n2, 0, -2):
            # n2부터 0까지 2씩 감소하면서 반복한다.
            if che[prime] and che[n - prime]:
                # prime과 n - prime이 모두 소수이면 출력하고 다음 테스트 케이스로 넘어간다.
                print(prime, n - prime)
                break
 
solution()

-- 원본: https://www.literateprograms.org/sieve_of_eratosthenes__haskell_.html
<<primes_naive>>=
primes :: [Integer] -- primes는 Integer의 리스트를 반환한다.
primes = sieve [2..]  2부터 시작하는 무한 리스트를 sieve 함수에 넘긴다.
  where -- `sieve` 는 다음과 같이 정의된다.
    sieve (p:xs) = p : sieve [x|x <- xs, x `mod` p > 0]
    -- `p`를 반환하고 `xs`에서 `p`의 배수를 제거한 리스트를 다시 `sieve`에 넘긴다.

from typing import Iterator  # Iterator 타입을 사용하기 위해 import한다.
# 뭔지 알면 따라하고 모르면 그냥 넘어가도 된다.
 
def sieve(xs: Iterator[int]) -> Iterator[int]:
    # `sieve` 함수는 정수 반복자를 받아서 정수 반복자를 반환한다.
    # 뭔지 모르면 `def sieve(xs):` 라고만 써도 된다.
    p = next(xs)  # `xs`의 첫번째 요소를 `p`에 할당한다.
    yield p  # p를 생성한다.
    # 위 두줄을 합쳐 `yield (p := next(xs))`로도 쓸 수 있다.
    yield from sieve(n for n in nums if n % p != 0)
    # `sieve` 함수에 `xs`에서 `p`의 배수를 제거한 반복자로부터 생성한다.

def count(start=0, step=1):
    n = start
    while True:
        yield n
        n += step

from itertools import count  # `count` 함수를 사용하기 위해 import한다.
 
def primes() -> Iterator[int]:
    # `primes` 함수는 정수 반복자를 반환한다.
    yield from sieve(count(2))
    # `sieve` 함수에 2부터 시작하는 반복자를 넘긴다.
 
# 혹은 2를 먼저 생성하고 3부터 홀수만 넘기는 방법도 있다.
 
def primes() -> Iterator[int]:
    yield 2
    # 2를 먼저 생성한다.
    yield from sieve(count(3, 2))
    # `sieve` 함수에 3부터 시작하는 홀수 반복자를 넘긴다.

def takewhile(predicate, iterable):
    for x in iterable:
        if predicate(x):
            yield x
        else:
            break

from itertools import takewhile
 
def primes_below(n: int) -> Iterator[int]:
    yield from takewhile(lambda x: x < n, primes())
    # `lambda x: x < n` 대신 `n.__gt__`를 넘겨도 된다.
    # 또한 `primes` 함수를 생략할 수도 있다.
 
# 상기한 주석을 반영하면 다음과 같이도 구현할 수 있다.
 
def primes_below(n):
    yield 2
    yield from takewhile(n.__gt__, sieve(count(3, 2)))

from typing import Iterator
from itertools import count, takewhile
 
def sieve(nums: Iterator[int]) -> Iterator[int]:
    n = next(nums)
    yield n
    yield from sieve(i for i in nums if i % n != 0)
 
 
def primes() -> Iterator[int]:
    yield 2
    yield from sieve(count(3, 2))
 
 
def primes_below(n: int) -> Iterator[int]:
    yield from takewhile(n.__gt__, primes())
 
 
is_prime = set(primes_below(10000)).__contains__

for _ in range(int(input())):
    n = int(input())
    if n == 4:
        print(2, 2)
    n2 = n // 2
    if n2 % 2 == 0:
        n2 -= 1
    for prime in range(n2, 0, -2):
        if che[prime] and che[n - prime]:
            print(prime, n - prime)
            break

def is_both_prime(nm):
    return all(map(is_primes, nm))

p, q = next(filter(is_both_prime, zip(range(np2, 0, -2), range(n - np2, n, 2))))
 
# 너무 기니까 변수를 분리하면
 
np2_and_n_m_np2 = zip(range(np2, 0, -2), range(n - np2, n, 2))
p, q = next(filter(is_both_prime, np2_and_n_m_np2))

def is_both_prime(nm):
    return all(map(is_primes, nm))
 
 
def divide_not_4(n):
    np2 = n // 2 - 1 + (n // 2) % 2
    np2_and_n_m_np2 = zip(range(np2, 0, -2), range(n - np2, n, 2))
    p, q = next(filter(is_both_prime, np2_and_n_m_np2))
    return f"{p} {q}"
    # 문자열로 출력해야하므로 f-string을 이용해 출력한다.

def divide(n):
    return "2 2" if n == 4 else divide_not_4(n)

def solution():
    next(input := map(int, open(0).read().split()))
    # input을 받아서 정수로 바꾸어준다.
    # 첫 입력인 테스트 케이스의 개수는 필요없으므로 버린다.
    print(*map(divide, input), sep="\n")
    # 테스트 케이스 별 답을 출력한다.

import sys
from itertools import count, takewhile
 
sys.setrecursionlimit(10000)
# 재귀 한도를 늘려준다.
 
def sieve(nums):
    yield (p := next(nums))
    yield from sieve(n for n in nums if n % p != 0)
 
 
def primes_below(n):
    # `primes`를 생략하고 바로 `primes_below`를 정의했다.
    yield 2
    yield from takewhile(n.__gt__, sieve(count(3, 2)))
 
 
is_primes = set(primes_below(10000)).__contains__
 
 
def is_both_prime(nm):
    return all(map(is_primes, nm))
 
 
def divide_not_4(n):
    np2 = n // 2 - 1 + (n // 2) % 2
    np2_and_n_m_np2 = zip(range(np2, 0, -2), range(n - np2, n, 2))
    p, q = next(filter(is_both_prime, np2_and_n_m_np2))
    return f"{p} {q}"
 
 
def divide(n):
    return "2 2" if n == 4 else divide_not_4(n)
 
 
def solution():
    next(input := map(int, sys.stdin.read().split()))
    print(*map(divide, input), sep="\n")
 
 
solution()

are_primes = set(primes_below(10000)).issuperset
 
 
def divide_not_4(n):
    np2 = n // 2 - 1 + (n // 2) % 2
    np2_and_n_m_np2 = zip(range(np2, 0, -2), range(n - np2, n, 2))
    p, q = next(filter(are_primes, np2_and_n_m_np2))
    return f"{p} {q}"